package zty.structures.sparsearray;

import java.io.*;

/**
 * 稀疏数组
 * @author tyzhang
 * @Date: 2021/1/7 10:34
 */
public class SparseArray {
    public static void main(String[] args) {
        // 数组-》稀疏数组，五子棋棋盘压缩为稀疏数组存储：
        // 数组中 0-空，1-黑色棋子，2-白色棋子
        int[][] chessAarray = new int[11][11];
        chessAarray[2][3] = 1;
        chessAarray[5][4] = 2;
        chessAarray[3][7] = 1;
        int sum = 0;
        // 二维数组棋盘，遍历数组，得到有效数据个数sum
        for (int[] row : chessAarray) {
            for (int data : row){
                if (data != 0){
                    sum++;
                }
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        System.out.println("棋子共有：" + sum);
        System.out.println("-------------------------------------------------------------------------------------------");
        // 根据sum创建稀疏数组sparsearray【sum+1】【3】
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = sum;

        // 将数据存入sparsearray中
        int count = 0;
        for (int i = 0; i < chessAarray.length; i++){
            for (int j = 0; j < chessAarray[i].length; j++){
                if (chessAarray[i][j] != 0){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessAarray[i][j];
                }
            }
        }
        // 打印稀疏数组
        System.out.println("稀疏数组为：");
        for (int[] row : sparseArray) {
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------------------------------------------------------");

        // 将稀疏数组存储到文件中：E:\IDEA\map.data
        System.out.println("准备存储。。。。。。");
        File file = new File("E:\\IDEA\\sparse\\map.data");
        File fileparent = file.getParentFile();
        // 先创建目录，才能创建文件
        if (!fileparent.exists()){
            fileparent.mkdirs();
        }
        if (!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            FileWriter fw = new FileWriter(file);
            for (int[] ints : sparseArray) {
                fw.write(ints[0] + "," + ints[1] + "," + ints[2] + ",");
            }
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("稀疏数组保存完成");
        System.out.println("-------------------------------------------------------------------------------------------");

        System.out.println("准备读取文件还原数组");
        // 定义一个字符串缓冲对象来接收读取到的字符
        StringBuffer sbuff = new StringBuffer();
        // 读取稀疏数组
        try {
            FileReader fr = new FileReader(file);
            // read（）读出来的默认是字节流，char转一下
            while (fr.ready()){
                sbuff.append((char) fr.read());
            }
            fr.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        String s = sbuff.toString();
        System.out.println("读取到的字符串缓冲对象：" + s);
        String[] split = s.split(",");
        // 根据读取到的数据创建稀疏数组
        int[][] sparseArray2 = new int[split.length/3][3];
        // 为恢复后稀疏数组的第一行赋值
        // 将String转换成int,使用Integer.parseInt()方法
        sparseArray2[0][0] = Integer.parseInt(split[0]);
        sparseArray2[0][1] = Integer.parseInt(split[1]);
        sparseArray2[0][2] = Integer.parseInt(split[2]);

        int row = 0;
        for (int i = 3; i < split.length; i+=3){
            row++;
            sparseArray2[row][0] = Integer.parseInt(split[i]);
            sparseArray2[row][1] = Integer.parseInt(split[i+1]);
            sparseArray2[row][2] = Integer.parseInt(split[i+2]);
        }
        // 查看稀疏数组
        for (int[] rows: sparseArray2){
            System.out.println(rows[0] +" "+ rows[1] +" "+ rows[2]);
        }
        System.out.println("-------------------------------------------------------------------------------------------");



        // 稀疏数组-》数组：
        // 先读取稀疏数组的第一行，根据第一行的数据，创建原始二维数组，
        int[][] chessAarray2 = new int[sparseArray2[0][0]][sparseArray2[0][1]];

        // 在读取稀疏数组后几行的数据，赋值给二维数组
        for (int i = 1; i < sparseArray2.length; i++){
            chessAarray2[sparseArray2[i][0]][sparseArray2[i][1]] = sparseArray2[i][2];
        }
        System.out.println();
        System.out.println("恢复后的二维数组");
        for (int[] rows : chessAarray2) {
            for (int data : rows) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

    }
}
